/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.ipartek.formacion.gestformwww.controlador;

import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.text.DateFormat;
import java.util.Date;

/**
 *
 * @author Borja
 */
public class Verificador {

    /**
     *
     * @param cadena linea de texto
     * @return si hay esta vacia o contiene caracteres incorrectos devuelve false
     */
    public static boolean esCorrecto(String cadena) {
        boolean correcto = false;
        //       if(!cadena.isEmpty()) dbaykbp.o
        if (cadena != null && !cadena.isEmpty()) //dbaykbp.n
        {
            correcto = caracteresCorrectos(cadena);
        }
        return correcto;
    }

    /**
     *
     * @param cadena
     * @return si hay caracteres incorrectos devuelve false
     */
    public static boolean caracteresCorrectos(String cadena) {
        boolean correcto = false;
        if (cadena == null) {      //dbaykbp.bn
            return true;
        }               //dbaykbp.en
        if (!(cadena.contains("'") || cadena.contains(";") || cadena.contains("$") || cadena.contains("&") || cadena.contains("?")
                || cadena.contains("--") || cadena.contains("/*") || cadena.contains("*/") || cadena.contains("*") || cadena.contains("%")
                || cadena.contains("+") || cadena.contains("=") || cadena.contains("\""))) //dbaykbp.n
        {
            correcto = true;
        }
        return correcto;
    }

    /**
     *
     * @param cadena
     * @param vacio true si puede estar vacio, false si no puede estar vacio
     * @return devuelve true si el formato de la hora es correcto
     */
    public static boolean validarHora(String cadena, boolean vacio) {//kbpydba
        String[] arrayhora;
        if (!vacio && (cadena == null || cadena.trim().isEmpty())) {
            return true;
        }
        arrayhora = cadena.split(":");
        if (arrayhora.length == 2) {
            if (Verificador.numeroValido(arrayhora[0], false)) {
                if (Verificador.numeroValido(arrayhora[1], false)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     *
     * @param fecha
     * @return devuelve true si el formato de la fecha es correcto
     */
    public static boolean fechaValida(String fecha) {//dba y kbp
        String[] arrayfecha;
        int dia;
        int mes;
        int anio;
        if (fecha == null || fecha.trim().equals("")) {
            return true;
        }
        arrayfecha = fecha.split("/");
        try {
            if (arrayfecha.length == 3) {
                dia = Integer.parseInt(arrayfecha[0]);
                mes = Integer.parseInt(arrayfecha[1]);
                anio = Integer.parseInt(arrayfecha[2]);
                if (dia < 32 && dia > 0) {//el formato del dia es correcto
                    if (mes < 13 && mes > 0) {//el formato del mes es válido
                        if (anio > 0) {
                            return true;
                        }
                    }
                }
            }
        } catch (NumberFormatException ex) {
            return false;
        }
        return false;
    }

//dbaykabp.bn
    /**
     * Si el segundo parametro (negativo) el false el número no pude ser negativo
     * @param numero
     * @param negativo si es true el numero puede ser negativo, si es false no
     * @return true si es un numero, false si no lo es
     */
    public static boolean numeroValido(String numero, boolean negativo) {
        int num;
        if (numero == null || numero.trim().equals("")) {
            return true;
        }
        try {
            num = Integer.parseInt(numero);
            if (!negativo && num < 0) {
                return false;
            }
        } catch (NumberFormatException ex) {
            return false;
        }
        return true;
    }
//dbaykabp.en

    //Víctor/Borja
    /**
     * Comprueba si el numero es valido
     * @param numero
     * @return si el numero es nulo vacio o no tiene formato correcto devuelve false
     */
    public static boolean numeroValido(String numero) {
        Integer num;
        boolean valido = false;
        if (numero != null && !numero.trim().isEmpty()) {
            try {
                num = Integer.parseInt(numero);
                if (num >= 0) {
                    valido = true;
                }
            } catch (NumberFormatException ex) {
                valido = false;
            }
        }
        return valido;
    }

    /**
     * Comprueba si el numero long es valido
     * @param numero
     * @return si el numero es nulo vacio o no tiene formato correcto devuelve false
     */
    public static boolean numeroLongValido(String numero) {
        Long num;
        boolean valido = false;
        if (numero != null && !numero.trim().isEmpty()) {
            try {
                num = Long.parseLong(numero);
                if (num >= 0) {
                    valido = true;
                }
            } catch (NumberFormatException ex) {
                valido = false;
            }
        }
        return valido;
    }

    public static boolean numeroFloatValido(String numero) {
        Float num;
        boolean valido = false;
        if (numero != null && !numero.trim().isEmpty()) {
            try {
                num = Float.parseFloat(numero);
                if (num >= 0) {
                    valido = true;
                }
            } catch (NumberFormatException ex) {
                valido = false;
            }
        }
        return valido;
    }

    /**
     *
     * @param fecha
     * @return fecha con el formato correcto
     */
    public static String formatearFecha(Timestamp fecha) {
        SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy");
        return formato.format(fecha.getTime());
    }
    /**
     *
     * @param fecha
     * @return fecha con el formato correcto
     */
    public static String formatearFecha(Date fecha) {
        SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy");
        return formato.format(fecha.getTime());
    }

    /**
     * Convierte un string en integer
     * @param parameter
     * @return
     */
    public static Integer stringAInt(String parameter) {
        Integer num = null;
        if (parameter != null) {
            try {
                num = Integer.parseInt(parameter);
            } catch (NumberFormatException ex) {
            }
        }
        return num;
    }

    /**
     * Comprueba que el dni es correcto
     * @param aluNIF
     * @return true si es correcto false si no lo es
     */
    public static boolean validarDni(String aluNIF) {
        boolean valido = false;
        if (aluNIF==null)
            return false;
        String dni = aluNIF.toUpperCase();
        String numero;
        if (aluNIF != null && !aluNIF.isEmpty()) {
            if (dni.charAt(0) == 'X') {
                numero = dni.substring(1, dni.length() - 1);
                if (numero.length() != 7 || !numeroValido(numero)) {
                    return false;
                }
            } else {
                numero = dni.substring(0, dni.length() - 1);
                if (numero.length() != 8 || !numeroValido(numero)) {
                    return false;
                }
            }

            char letra = dni.charAt(dni.length() - 1);
            Integer num = Integer.parseInt(numero) % 23;
            String letras = "TRWAGMYFPDXBNJZSQVHLCKET";
            if (letra == letras.charAt(num)) {
                valido = true;
            }
        }
        return valido;
    }

    /**
     * Recibe un string y lo convierte en fecha
     * @param cadenafecha
     * @return
     */
    public Timestamp convertirEnFecha(String cadenafecha) {
        Timestamp fecha = Timestamp.valueOf(cadenafecha);
        return fecha;
    }

    //Víctor/Aitor
    /***
     * Si el string es null devuelve string vacio
     * @param string
     * @return
     */
    public static String comprobar(String string) {
        if (string == null) {
            return "";
        } else {
            return string;
        }
    }

    /**
     * Si el integer es null te devuelve string vacio, si no es null devuelve string
     * @param num
     * @return
     */
    public static String comprobar(Integer num) {
        if (num == null) {
            return "";
        } else {
            return num.toString();
        }
    }
     /**
     * Si el integer es 0 te devuelve string vacio, si no es null devuelve string
     * @param num
     * @return
     */
    public static String comprobarCeros(Integer num) {
        if (num == 0) {
            return "";
        } else {
            return num.toString();
        }
    }
    public static String comprobarCeros(Float num) {
        if (num == 0.0) {
            return "";
        } else {
            return num.toString();
        }
    }

    /**
     * Si la fecha es null te devuelve string vacio, si no es null devuelve string
     * @param fecha
     * @return
     */
    public static String comprobar(Timestamp fecha) {
        if (fecha == null) {
            return "";
        } else {
            return formatearFecha(fecha);
        }
    }
    /**Cuando la fecha es de tipo DATE
     * Si la fecha es null te devuelve string vacio, si no es null devuelve string
     * @param fecha
     * @return
     */
    public static String comprobar(Date fecha) {
        if (fecha == null) {
            return "";
        } else {
            return formatearFecha(fecha);
        }
    }

    /**
     * si el boolean es true devuelve checked para marcar el check box, sino devuelve vacio
     * @param bool
     * @return
     */
    public static String comprobar(Boolean bool) {
        if (bool == null) {
            return "";
        } else {
            if (bool) {
                return "checked";
            } else {
                return "";
            }
        }
    }

    /**
     * Si el float es null te devuelve string vacio, si no es null devuelve string
     * @param valor
     * @return
     */
    public static String comprobar(Float valor) {
        if (valor == null) {
            return "";
        } else {
            return valor.toString();
        }
    }

    /**
     * Convierte un string a fecha
     * @param cadena
     * @return
     */
    public static Timestamp stringAFecha(String cadena) {
        Timestamp fecha = null;
        if (cadena != null) {
            String[] datos = cadena.split("/");
            try {
                int dia = Integer.parseInt(datos[0]);
                int mes = Integer.parseInt(datos[1]);
                int anio = Integer.parseInt(datos[2]); //COMPROBAR SI METE SOLO 2 CIFRAS
                fecha = Timestamp.valueOf(anio + "-" + (mes < 10 ? "0" : "") + mes + "-" + (dia < 10 ? "0" : "") + dia + " 00:00:00");
            } catch (Exception ex) {
                fecha = null;
            }
        }
        return fecha;
    }

    public static boolean ordenFechasCorrecto(Timestamp f1, Timestamp f2) {
        return (f1.before(f2) || f1.equals(f2));
    }

    /**
     * Comprueba si la segunda fecha es mayor que la primera, y que ambas tengan formato correcto
     * @param fecha1
     * @param fecha2
     * @return si es correcto true, sino false
     */
    public static boolean ordenFechasCorrecto(String fecha1, String fecha2) {//kabpydba
        boolean correcto = false;
        String[] arrayfecha1;
        String[] arrayfecha2;
        if (fecha1.compareTo("") == 0 || fecha2.compareTo("") == 0) {
            return true;
        }
        arrayfecha1 = fecha1.split("/");
        arrayfecha2 = fecha2.split("/");
        if (arrayfecha1.length != 3 || arrayfecha2.length != 3) {
            return false;
        }
        if (Integer.parseInt(arrayfecha1[2]) < Integer.parseInt(arrayfecha2[2])) {
            correcto = true;
        } else if (Integer.parseInt(arrayfecha1[2]) == Integer.parseInt(arrayfecha2[2])) {
            if (Integer.parseInt(arrayfecha1[1]) < Integer.parseInt(arrayfecha2[1])) {
                correcto = true;
            } else if (Integer.parseInt(arrayfecha1[1]) == Integer.parseInt(arrayfecha2[1])) {
                if (Integer.parseInt(arrayfecha1[0]) <= Integer.parseInt(arrayfecha2[0])) {
                    correcto = true;
                }
            }
        }
        return correcto;
    }

    /**
     * Comprueba que el formato de las hotas es correcto y que la segunda es posterior a la primera
     * @param hora1
     * @param hora2
     * @return
     */
    public static boolean ordenHorasCorrecto(String hora1, String hora2) {//kabpydba
        boolean correcto = false;

        String[] arrayhora1;
        String[] arrayhora2;
        /*  if (hora1.isEmpty()|| hora2.isEmpty())
        {
        return false;
        }*/
        arrayhora1 = hora1.split(":");
        arrayhora2 = hora2.split(":");

        if (arrayhora1.length != 2 || arrayhora2.length != 2) {
            return true;
        }
        if (Integer.parseInt(arrayhora1[0]) < Integer.parseInt(arrayhora2[0])) {
            correcto = true;
        } else if (Integer.parseInt(arrayhora1[0]) == Integer.parseInt(arrayhora2[0])) {
            if (Integer.parseInt(arrayhora1[1]) < Integer.parseInt(arrayhora2[1])) {
                correcto = true;
            }
        }

        return correcto;
    }

    public static boolean comprobarHoras(String h1, String h2) {
        boolean correcto = false;
        if (h1 != null && h2 != null && !h1.isEmpty() && !h2.isEmpty()) {
            correcto = ordenHorasCorrecto(h1, h2);
        }
        return correcto;
    }

    /**
     * Comprueba el formato de la hora
     * @param cadena
     * @param vacio
     * @return
     */
    public static boolean validarFormatoHora(String cadena, boolean vacio) {
        //Adrian
        //Comprueba que no valide una hora con el formato 9:00
        //pòrque en la BBDD entraria como null
        //El formato tiene que ser 09:00
        String[] arrayhora;
        if (!vacio && (cadena == null || cadena.trim().isEmpty())) {
            return false;
        }
        arrayhora = cadena.split(":");
        if (arrayhora.length == 2) {
            if (Verificador.numeroValido(arrayhora[0], false)) {
                if (Verificador.numeroValido(arrayhora[1], false)) {
                    //if (arrayhora[0].length() == 2 && arrayhora[1].length() == 2) {
                    return true;
                    //}
                }
            }
        }
        return false;
    }

    /**
     * Comprueba que las fechas al mes no sean mayores que las faltas totales
     * @param fTotales
     * @param fMes
     * @return
     */
    public static boolean compararFaltas(String fTotales, String fMes) {

        try {
            if (Integer.parseInt(fTotales) >= Integer.parseInt(fMes)) {
                return true;
            }
            return false;
        } catch (NumberFormatException ex) {

            return true;
        }

    }

    /**
     * Recorta un texto a un tamaño, añadiendo puntos suspensivos al final.
     * Los caracteres en blanco al final y principio de la cadena se eliminan al recortarla.
     *
     * @param tamaño máximo de la cadena que devolverá.
     * @param Texto que se cortará.
     * @return El texto original recortado.
     */
    public static String recortarCadena(int tamanio, String cadena) {
        String cadenanueva;
        if (cadena.trim().length() > tamanio + 3) {
            cadenanueva = cadena.trim().substring(0, tamanio) + "...";
        } else {
            cadenanueva = cadena;
        }
        return cadenanueva;
    }
    //Adrian

    public static boolean esEmail(String email) {
        boolean esMail = false;
        Pattern p = Pattern.compile("^[a-zA-Z0-9_.-]{2,}@[a-zA-Z0-9_-]{2,}\\.[a-zA-Z]{2,4}(\\.[a-zA-Z]{2,4})?$");
        if (email != null) {
            Matcher m = p.matcher(email);
            if (m.matches()) {
                esMail = true;
            }
            if (email.equals("")) {
                esMail = true;
            }
        }
        return esMail;
    }
    //Josean

    public static boolean esNSS(String numero) {
        Long num;
        boolean valido = false;
        if (numero != null && !numero.trim().isEmpty()) {
            try {
                num = Long.parseLong(numero);
                if (num >= 0) {
                    valido = true;
                }
            } catch (NumberFormatException ex) {
                valido = false;
            }
        }
        return valido;
    }

    public static boolean minutoValido(String numero) {
        int minutos;
        try {
            minutos = Integer.parseInt(numero);
        } catch (NumberFormatException ex) {
            return false;
        }
        if (minutos > 59 || minutos < 0) {
            return false;
        }
        return true;
    }

    public static boolean sinReenvio(String input, HttpSession sesion, HttpServletRequest request) {
        boolean ejecutar = true;
        String aleatorio = (String) sesion.getAttribute(input);
        if (aleatorio != null) {
            if (request.getParameter(input) != null) {
                if (request.getParameter(input).equals(aleatorio)) {
                    // Si se pulsa F5 o atras el aleatorio del request será igual al de la sesión.
                    // NO debe crease un alumno (ya se creo anteriormente)
                    ejecutar = false;
                } else {
                    sesion.setAttribute(input, request.getParameter(input));
                }
            }
        } else {
            sesion.setAttribute(input, request.getParameter(input));
        }
        return ejecutar;
    }

    public static boolean comprobarIntervaloHoras(String hIni1, String hFin1, String hIni2, String hFin2) {
        boolean solapan = false;
        if (comprobarHoras(hIni1, hIni2)) {
            if (comprobarHoras(hIni2, hFin1)) {
                solapan = true;
            } else {
                solapan = false;
            }
        } else {
            if (comprobarHoras(hIni1, hFin2)) {
                solapan = true;
            } else {
                solapan = false;
            }

        }
        return solapan;
    }

    public static String convertirFecha(Calendar c) {
        String cadena = null;
        switch (c.get(Calendar.MONTH)) {
            case Calendar.JANUARY:
                cadena = "Enero";
                break;
            case Calendar.FEBRUARY:
                cadena = "Febrero";
                break;
            case Calendar.MARCH:
                cadena = "Marzo";
                break;
            case Calendar.APRIL:
                cadena = "Abril";
                break;
            case Calendar.MAY:
                cadena = "Mayo";
                break;
            case Calendar.JUNE:
                cadena = "Junio";
                break;
            case Calendar.JULY:
                cadena = "Julio";
                break;
            case Calendar.AUGUST:
                cadena = "Agosto";
                break;
            case Calendar.SEPTEMBER:
                cadena = "Septiembre";
                break;
            case Calendar.OCTOBER:
                cadena = "Octubre";
                break;
            case Calendar.NOVEMBER:
                cadena = "Noviembre";
                break;
            case Calendar.DECEMBER:
                cadena = "Diciembre";
                break;
            default:
                cadena = "";
        }
        return cadena + " " + c.get(Calendar.YEAR);
    }

    public static String fechaString(Calendar c) {
        String cadena = null;
        cadena = c.get(Calendar.DAY_OF_MONTH) + "/" + (c.get(Calendar.MONTH) + 1) + "/" + c.get(Calendar.YEAR);
        return cadena;
    }

    public static String formatearHora(Timestamp c) {

        DateFormat df = DateFormat.getTimeInstance();
        df.getTimeInstance(DateFormat.SHORT);

        return df.format(c);
    }

    public static Calendar stringFecha(String cadena) {
        Calendar c = null;
        if (cadena != null && !cadena.isEmpty()) {
            c = Calendar.getInstance();
            String fecha[] = cadena.split("/");
            c.set(Integer.parseInt(fecha[2]), Integer.parseInt(fecha[1]) - 1, Integer.parseInt(fecha[0]));
        }
        return c;
    }

    public static int convertirHoraAMinutos(String hora) {
        String[] horas;
        int h;
        int m;
        int minutos;
        int numero;
        horas = hora.split(":");

        h = Integer.parseInt(horas[0]);
        m = Integer.parseInt(horas[1]);

        minutos = (h * 60) + m;

        return minutos;

    }

    public static boolean comprobarTelefono(String tlfn) {
        if (tlfn != null) {
           //if (tlfn.isEmpty() || !tlfn.trim().startsWith("6")) {
           if (tlfn.isEmpty()) {
                return false;
            } else {
                return true;
            }
        }else {
            return false;
        }
    }

    /**
     * @author Adrian y Sara
     * @param movil Telefono movil a comprobar
     * @return True si el telefono a comprobar es correcto
     */
    public static boolean esMovil(String movil) {
        boolean res = false;

        if (movil.length() == 9) {
            //9 digitos
            if (movil.substring(0, 1).equalsIgnoreCase("6")) {
                //Empieza por 6
                res = true;
            }
        }
        return res;
    }

    /**
     * @author Adrian y Sara
     * @param fijo Telefono fijo a comprobar
     * @return True si el telefono a comprobar es correcto
     */
    public static boolean esFijo(String fijo) {
        boolean res = false;

        if (fijo.length() == 9) {
            //9 digitos
            if (fijo.substring(0, 1).equalsIgnoreCase("9")) {
                //Empieza por 9
                res = true;
            }
        }
        return res;
    }


    /**
     * @author Víctor y Sara
     * @param f Fecha a comprobar
     * @param f1 Fecha de inicio
     * @param f2 Fecha de fin
     * @return True si la fecha a comprobar se encuentra entre la fecha de inicio y fin
     */
    public static boolean fechaEntre(Timestamp f, Timestamp f1, Timestamp f2) {
        boolean resultado = false;
        String s = comprobar(f);
        String s1 = comprobar(f1);
        String s2 = comprobar(f2);
        if (ordenFechasCorrecto(s1, s) && ordenFechasCorrecto(s, s2)) {
            resultado = true;
        }
        return resultado;
    }
    /**
     * Metodo que calcula los meses que hay entre dos fechas
     * @param nDi0, dia de la primera fecha
     * @param nMe0, mes de la primera fecha
     * @param nAn0, año de la primera fecha
     * @param nDi1, dia de la segunda fecha
     * @param nMe1, mes de la segunda fecha
     * @param nAn1, año de la segunda fecha
     * @return nRes, el numero de meses que hay entre las fechas
     */
    public static int mesesEntre(int nDi0, int nMe0, int nAn0, int nDi1, int nMe1, int nAn1){
    int nRes;
    if ((nMe1 < nMe0) || ((nMe1 == nMe0) && (nDi1 < nDi0))) nMe1 += 12;
//        nRes = Math.max(0, nMe1 - nMe0 - 1);
        nRes = (nAn1*12 + nMe1) -(nAn0*12 + nMe0);
    if ((nDi1 > nDi0))
//        && (nMe1 != nMe0)
        nRes=nRes-1;
    
    return nRes;
   }
//     f1 = "2007/02/03";
//  f2 = "2007/06/04";
//
//  aF1 = f1.split("/");
//  aF2 = f2.split("/");
//
//  numMeses = aF2[0]*12 + aF2[1] - (aF1[0]*12 + aF1[1]);
//  if (aF2[2]<aF1[2]){
//    numMeses = numMeses - 1;
//  }
//  alert(numMeses);
}
